<script>

import { objectAssign, formatDate } from "../../utils/common";
import { server_request } from "../../utils/request";
import ServerUpload from "./ServerUpload";
import uploadConfig from "../../config/upload";
import bosUpload from "../../utils/upload/bos";
import async from 'async';

/**
 *
    文件上传 - 百度云bos
    使用前，请确保 public目录下，有引用如下脚本：
    /@baiducloud/sdk/dist/baidubce-sdk.bundle.min.js

    如果public目录下没有该脚本，则用npm安装 @baiducloud/sdk 
    安装命令：npm install @baiducloud/sdk
    然后将 node_modules 目录下的 @baiducloud，拷贝到 public/ 目录下。

    同时还需要安装 async （https://github.com/caolan/async）
    安装命令：
    npm install async

    bos要配置跨域，配置方式见下方文档
    https://cloud.baidu.com/doc/BOS/s/Ckcbqn8bz

 * 
 */
export default {
    extends: ServerUpload,
    name: "PopoBosUpload",
    data(){
        return {
            sts: null,
            stsLoaded: false,
            client: null,
        };
    },
    created(){
        this.opt.action = "";
        this.opt.httpRequest = this.httpRequest;
        this.sts = this.item.sts;
        // console.log( baidubce.sdk.BosClient);
        // console.log( "BosClient", BosClient, Q.defer, async);
    },
    methods: {
        /**
         * 上传OSS请求
         * 
         * @param  {[type]} http [description]
         * @return {[type]}      [description]
         */
        httpRequest( http){
            /*
            http: {
                action: ""
                data: undefined
                file: File {uid: 1595394989063, name: "123.jpg", webkitRelativePath: "", …}
                filename: "file"
                headers: {__ob__: Observer}
                onError: ƒ onError(err)
                onProgress: ƒ onProgress(e)
                onSuccess: ƒ onSuccess(res)
                withCredentials: false
            }                
             */
            bosUpload( 
                http.file, 
                {
                    sts: this.sts,
                    fileOnlinePath: this.getRandomFileInfo( http.file).final,
                    progress: (e)=>{
                        http.onProgress( { percent: e.percent});
                    },
                    success: (e)=>{
                        http.onSuccess(e)
                    },
                    failure: (e)=>{
                        console.error( "上传失败", e);
                        http.onError( "上传失败");
                    }
                }
            );

            return;
            
            // console.log( "httpRequest", arguments);
            // var bos_config = objectAssign( {}, uploadConfig.bos.upload_config);

            // /*
            //     优先使用stsToken的方式进行鉴权，可支持在 item.sts 中传入已有的数据，也可以
            //     通过 upload.js 中的 uploadConfig.bos.get_sts_token_url 的配置，通过
            //     ajax来获得 stsToken。 
            //     如果都没有，则使用最不安全的 accessKeyId/accessKeySecret 的直传模式。
            //  */
            // if( this.sts){
            //     // 使用 sts方式进行oss鉴权。
            //     bos_config.credentials.ak = this.item.sts.credentials.ak;
            //     bos_config.credentials.sk = this.item.sts.credentials.sk;
            //     bos_config.sessionToken = this.item.sts.credentials.sessionToken;

            //     this.doUpload( bos_config, http);

            // }else if( !!uploadConfig.bos.get_sts_token_url && !this.stsLoaded){

            //     // 获得ajax方式获得 sts 数据
            //     server_request( uploadConfig.bos.get_sts_token_url).then( (res) => {
            //         // 防止反复调用 sts 接口
            //         this.stsLoaded = true;
            //         if( res.code == 200){
            //             this.sts = res.data;
            //             this.httpRequest( http);
            //         }else{
            //             this.$message.error( "获取bos临时凭证失败");
            //         }
            //     });

            // }else{
            //     this.doUpload( bos_config, http);
            // }

        },
        // doUpload( bos_config, http){
        //     // console.log( "bos_config", bos_config);

        //     let client = new baidubce.sdk.BosClient( bos_config);

        //     try{
        //         let tempCheckpoint = null;
        //         let fileInfo = this.getRandomFileInfo( http.file);
        //         let fileFinalPath = fileInfo.final;

        //         let key = fileFinalPath;
        //         let bucket = bos_config.bucket;
        //         let uploadId = null ;

        //         let options = {
        //         };

        //         client.initiateMultipartUpload( bucket, key, options)
        //             .then((response) => {
        //                 uploadId = response.body.uploadId; // 开始上传，获取服务器生成的uploadId

        //                 let deferred = baidubce.sdk.Q.defer();
        //                 let tasks = this.getTasks( http.file, uploadId, bucket, key);
        //                 let state = {
        //                     lengthComputable: true,
        //                     loaded: 0,
        //                     total: tasks.length
        //                 };

        //                 // 为了管理分块上传，使用了async（https://github.com/caolan/async）库来进行异步处理
        //                 let THREADS = 2; // 同时上传的分块数量
        //                 async.mapLimit(tasks, THREADS, this.uploadPartFile(state, client, http), (err, results)=>{
        //                     // console.log( "on finish", err, results, state);
        //                     if (err) {
        //                         deferred.reject(err);
        //                     } else {
        //                         deferred.resolve(results);
        //                     }
        //                 });
        //                 return deferred.promise;
        //             })
        //             .then( (allResponse) =>{
        //                 let partList = [];
        //                 allResponse.forEach(function(response, index) {
        //                     // 生成分块清单
        //                     partList.push({
        //                         partNumber: index + 1,
        //                         eTag: response.http_headers.etag
        //                     });
        //                 });
        //                 return client.completeMultipartUpload(bucket, key, uploadId, partList); // 完成上传
        //             })
        //             .then(function (res) {
        //                 // 上传完成
        //                 // console.log( "upload done", res);
        //                 http.onSuccess( {
        //                     code: 200,
        //                     msg: "success",
        //                     data: res.body.location, 
        //                 });
        //             })
        //             .catch(function (err) {
        //                 // 上传失败，添加您的代码
        //                 console.error("upload error", err);
        //                 http.onError( err);
        //             });

        //     }catch( e){
        //         http.onError( "上传失败");
        //         // client.cancel();
        //         console.error( e);
        //     }
        // },
        // // 对文件进行分块
        // getTasks(file, uploadId, bucketName, key) {

        //     let PART_SIZE = 1 * 1024 * 1024; // 指定分块大小  1Mb 一块

        //     let leftSize = file.size;
        //     let offset = 0;
        //     let partNumber = 1;

        //     let tasks = [];

        //     while (leftSize > 0) {
        //         let partSize = Math.min(leftSize, PART_SIZE);
        //         tasks.push({
        //             file: file,
        //             uploadId: uploadId,
        //             bucketName: bucketName,
        //             key: key,
        //             partNumber: partNumber,
        //             partSize: partSize,
        //             start: offset,
        //             stop: offset + partSize - 1
        //         });

        //         leftSize -= partSize;
        //         offset += partSize;
        //         partNumber += 1;
        //     }
        //     // console.log( "task", tasks);
        //     return tasks;
        // },
        // uploadPartFile(state, client, http) {
        //     return (task, callback) =>{
        //         let blob = task.file.slice(task.start, task.stop + 1);
        //         // console.log( "upload blob", blob);
        //         // debugger;
        //         client.uploadPartFromBlob(task.bucketName, task.key, task.uploadId, task.partNumber, task.partSize, blob)
        //             .then(function(res) {
        //                 ++state.loaded;
        //                 console.log( "onProgress", state);
        //                 http.onProgress( { percent: Math.floor( ( state.loaded / state.total ) * 100)});
        //                 callback(null, res);
        //             })
        //             .catch(function(err) {
        //                 callback(err);
        //             });
        //     };
        // }
    }
};
</script>

